/**
 * 各种转换、格式化方法或工具
 * @author 董一华
 * @since 1.00
 * @version 1.00 
 * 
 * 修订列表： v1.00 2009-10-24 
 * 			修订人：董一华 
 * 			修订内容：初始版本 
 */
package com.zjht.gmcc.bean.util;

import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.zjht.gmcc.bean.model.DataArray;
import com.zjht.gmcc.bean.model.DataArrayColRepeat;
import com.zjht.gmcc.bean.model.DataArrayRowRepeat;

public class MyFormat {
	/******************* 1. 日期方法开始 ***************************/

	/**
	 * 获取Calendar
	 * @author dyh 2011-11-12
	 * @param date YYYY-MM-dd
	 * @return 如果有异常，则返回今天
	 */
	public static Calendar getCalendar(String date) {
		return getCalendar(date, "yyyy-MM-dd");
	}

	/**
	 * 获取Calendar
	 * @author dyh 2011-11-12
	 * @param date
	 * @param format date的格式
	 * @return
	 */
	public static Calendar getCalendar(String date, String format) {
		return getCalendar(date, new SimpleDateFormat(format));
	}

	/**
	 * 获取Calendar
	 * @author dyh 2011-11-12
	 * @param date
	 * @param format date的格式
	 * @return
	 */
	public static Calendar getCalendar(String date, SimpleDateFormat format) {
		Calendar calendar = Calendar.getInstance();
		if (format != null) {
			try {
				calendar.setTime(format.parse(date));
			} catch (Exception e) {
			}
		}
		return calendar;
	}

	/******************* 1.1 日期方法开始：时分秒 ***************************/
	/**
	 * 获取当前时间HH:mm:ss
	 * @author dyh 2009-10-24
	 * @return HH:mm:ss
	 */
	public final static String getCurrentTime() {
		Date date = new Date();
		SimpleDateFormat df = new SimpleDateFormat("HH:mm:ss");
		return df.format(date);
	}

	// 考核报表的时长计算
	// 输入分钟数，返回“X天X小时X分钟”
	public static String getTime(int minute) {
		String strTime = "";
		int iDay = 0, iHour = 0, iMinute = 0, tmp = 0;
		tmp = minute;
		if (tmp > 0) {
			if (tmp / 1440 >= 1) {
				iDay = tmp / 1440;
				tmp = tmp - iDay * 1440;
			}

			if (tmp / 60 >= 1) {
				iHour = tmp / 60;
				tmp = tmp - iHour * 60;
			}

			iMinute = tmp;

			if (iDay > 0)
				strTime += iDay + "天";
			if (iHour > 0)
				strTime += iHour + "小时";
			if (iMinute > 0) {
				if (iDay > 0 && iHour == 0)
					strTime += "0小时";
				strTime += iMinute + "分钟";
			}
		} else if (tmp == 0)
			strTime = "0分钟";
		return strTime;
	}

	// 输入毫秒，返回“X天X小时X分钟X秒”
	public static String formatTime(long millisecond) {
		String strTime = "";
		long iDay = 0, iHour = 0, iMinute = 0, iSecond = 0, iMillisecond = 0, tmp = 0;
		tmp = millisecond;
		if (tmp > 0) {
			if (tmp / 86400000 >= 1) {
				iDay = tmp / 86400000;
				tmp = tmp - iDay * 86400000;
			}
			if (tmp / 3600000 >= 1) {
				iHour = tmp / 3600000;
				tmp = tmp - iHour * 3600000;
			}
			if (tmp / 60000 >= 1) {
				iMinute = tmp / 60000;
				tmp = tmp - iMinute * 60000;
			}
			if (tmp / 1000 >= 1) {
				iSecond = tmp / 1000;
				tmp = tmp - iSecond * 1000;
			}
			iMillisecond = tmp;

			if (iDay > 0)
				strTime += iDay + "天";
			if (iHour > 0)
				strTime += iHour + "小时";
			if (iMinute > 0) {
				if (iDay > 0 && iHour == 0)
					strTime += "0小时";
				strTime += iMinute + "分钟";
			}
			if (iSecond > 0) {
				if (iDay > 0) {
					if (iHour == 0)
						strTime += "0小时";
					if (iMinute == 0)
						strTime += "0分钟";
				} else if (iHour > 0) {
					if (iMinute == 0)
						strTime += "0分钟";
				}
				strTime += iSecond + "秒";
			}
			if (iMillisecond > 0) {
				if (iDay > 0) {
					if (iHour == 0)
						strTime += "0小时";
					if (iMinute == 0)
						strTime += "0分钟";
					if (iSecond == 0)
						strTime += "0秒";
				} else if (iHour > 0) {
					if (iMinute == 0)
						strTime += "0分钟";
					if (iSecond == 0)
						strTime += "0秒";
				} else if (iMinute > 0) {
					;
					if (iSecond == 0)
						strTime += "0秒";
				}
				strTime += iMillisecond + "毫秒";
			}
		} else if (tmp == 0)
			strTime = "0毫秒";
		return strTime;
	}

	/**
	 * 输入当前时间，判断是否在开始和结束时间段内
	 * @author dyh 2011-1-11
	 * @param now HH:mm
	 * @param starttime HH:mm
	 * @param endtime HH:mm
	 * @return
	 */
	public static boolean isInTime(String now, String starttime, String endtime) {
		if (isStrNull(now) || isStrNull(starttime) || isStrNull(endtime)) {
			return false;
		}
		if (starttime.compareTo(endtime) > 0) {// 如果开始时间迟于结束时间，则需要对调
			String tmp = starttime;
			starttime = endtime;
			endtime = tmp;
		}
		return now.compareTo(starttime) >= 0 && now.compareTo(endtime) <= 0;
	}

	/**
	 * 判断当前时间是否在开始和结束时间段内
	 * @author dyh 2011-1-11
	 * @param starttime HH:mm
	 * @param endtime HH:mm
	 * @return
	 */
	public static boolean isInTime(String starttime, String endtime) {
		DateFormat df = new java.text.SimpleDateFormat("HH:mm");
		return isInTime(df.format(Calendar.getInstance().getTime()), starttime, endtime);
	}

	/******************* 1.1 日期方法结束：时分秒 ***************************/

	/******************* 1.2 日期方法开始：日 ***************************/
	/**
	 * 按"yyyy-MM-dd HH:mm"格式化日期
	 * @author dyh 2009-10-24
	 * @param date 日期
	 * @return 返回格式化后的日期
	 */
	public final static String getDateFormat(Date date) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		return df.format(date);
	}

	/**
	 * 按"yyyy-MM-dd HH:mm:ss"格式化日期
	 * @author dyh 2009-10-24
	 * @param date 日期
	 * @return 返回格式化后的日期
	 */
	public final static String getFullDate(Date date) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String strDate = null;
		try {
			strDate = df.format(date);
		} catch (Exception e) {
		}
		return strDate;
	}

	/**
	 * 将"yyyy-MM-dd HH:mm:ss"转化成Date
	 * @author dyh 2009-10-24
	 * @param strDate yyyy-MM-dd HH:mm:ss
	 * @return 返回Date
	 */
	public final static Date setFullDate(String strDate) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date date = null;
		try {
			date = df.parse(strDate);
		} catch (Exception e) {
			date = null;
		}
		return date;
	}

	/**
	 * 获取今天(日期)
	 * @author dyh 2009-10-24
	 * @return yyyy-MM-dd
	 */
	public final static String getToday() {
		Date date = new Date();
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		return df.format(date);
	}

	/**
	 * 获取今天(中文日期)
	 * @author dyh 2009-10-24
	 * @return yyyy年MM月dd日
	 */
	public final static String getTodayInCN() {
		Date date = new Date();
		SimpleDateFormat df = new SimpleDateFormat("yyyy年M月d日");
		return df.format(date);
	}

	/**
	 * 获取今天(yyyy-MM-dd HH:mm:ss)
	 * @author dyh 2009-10-24
	 * @return yyyy-MM-dd HH:mm:ss
	 */
	public final static String getTodayFull() {
		Date date = new Date();
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return df.format(date);
	}

	/**
	 * 获取本日
	 * @author dyh 2009-12-24
	 * @return
	 */
	public final static int getDay() {
		Date date = new Date();
		SimpleDateFormat df = new SimpleDateFormat("dd");
		String day = df.format(date);
		return Integer.parseInt(day);
	}

	/**
	 * 输入Date，输出日期
	 * @author dyh 2011-01-18
	 * @param date YYYY-MM-DD
	 * @return
	 */
	public final static int getDay(String date) {
		return MyFormat.formatInt(date.substring(8));
	}

	/**
	 * 获取上月1日
	 * @author dyh 2009-10-24
	 * @return
	 */
	public final static String getFirstDayInLastMonth() {
		return getFirstDayInLastMonth(getToday());
	}

	/**
	 * 获取上月最后一日
	 * @author dyh 2010-08-26
	 * @return
	 */
	public final static String getLastDayInLastMonth() {
		return getLastDayInLastMonth(getToday());
	}

	/**
	 * 获取本月1日
	 * @author dyh 2009-10-24
	 * @return
	 */
	public final static String getFirstDayInThisMonth() {
		return getFirstDayInThisMonth(getToday());
	}

	/**
	 * 获取本月最后一日
	 * @author dyh 2010-08-26
	 * @return
	 */
	public final static String getLastDayInThisMonth() {
		return getLastDayInThisMonth(getToday());
	}

	/**
	 * 获取下月1日
	 * @author dyh 2010-08-26
	 * @return
	 */
	public final static String getFirstDayInNextMonth() {
		return getFirstDayInNextMonth(getToday());
	}

	/**
	 * 获取下月最后一日
	 * @author dyh 2010-08-26
	 * @return
	 */
	public final static String getLastDayInNextMonth() {
		return getLastDayInNextMonth(getToday());
	}

	/**
	 * 获取输入日期的上月1日
	 * @author dyh 2010-03-21
	 * @param date yyyy-mm-dd
	 * @return
	 */
	public final static String getFirstDayInLastMonth(String date) {
		if (date == null || date.length() != 10)
			return "";
		String lastDay = "";
		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(df.parse(date));
			calendar.add(Calendar.MONTH, -1);
			lastDay = df.format(calendar.getTime());
		} catch (Exception e) {
		}
		return lastDay.substring(0, 7) + "-01";
	}

	/**
	 * 获取输入日期的上月最后一日
	 * @author dyh 2010-08-21
	 * @param date yyyy-mm-dd
	 * @return
	 */
	public final static String getLastDayInLastMonth(String date) {
		if (date == null || date.length() != 10)
			return "";
		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(df.parse(date.substring(0, 7) + "-01"));
			calendar.add(Calendar.DAY_OF_MONTH, -1);
			date = df.format(calendar.getTime());
		} catch (Exception e) {
		}
		return date;
	}

	/**
	 * 获取输入日期的本月1日
	 * @author dyh 2010-03-21
	 * @param date yyyy-mm-dd
	 * @return
	 */
	public final static String getFirstDayInThisMonth(String date) {
		if (date == null || date.length() != 10)
			return "";
		return date.substring(0, 7) + "-01";
	}

	/**
	 * 获取输入日期的本月最后一日
	 * @author dyh 2010-08-17
	 * @param date yyyy-mm-dd
	 * @return
	 */
	public final static String getLastDayInThisMonth(String date) {
		if (date == null || date.length() != 10)
			return "";
		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(df.parse(date.substring(0, 7) + "-01"));
			calendar.add(Calendar.MONTH, 1);
			calendar.add(Calendar.DAY_OF_MONTH, -1);
			date = df.format(calendar.getTime());
		} catch (Exception e) {
		}
		return date;
	}

	/**
	 * 获取输入日期的下月1日
	 * @author dyh 2010-08-26
	 * @param date yyyy-mm-dd
	 * @return
	 */
	public final static String getFirstDayInNextMonth(String date) {
		if (date == null || date.length() != 10)
			return "";
		String lastDay = "";
		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(df.parse(date));
			calendar.add(Calendar.MONTH, 1);
			lastDay = df.format(calendar.getTime());
		} catch (Exception e) {
		}
		return lastDay.substring(0, 7) + "-01";
	}

	/**
	 * 获取输入日期的下月最后一日
	 * @author dyh 2010-08-21
	 * @param date yyyy-mm-dd
	 * @return
	 */
	public final static String getLastDayInNextMonth(String date) {
		if (date == null || date.length() != 10)
			return "";
		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(df.parse(date.substring(0, 7) + "-01"));
			calendar.add(Calendar.MONTH, 2);
			calendar.add(Calendar.DAY_OF_MONTH, -1);
			date = df.format(calendar.getTime());
		} catch (Exception e) {
		}
		return date;
	}

	/**
	 * 获取今年第1天
	 * @author dyh 2010-12-31
	 * @return
	 */
	public final static String getFirstDayInThisYear() {
		return getFirstDayInThisYear(getToday());
	}

	/**
	 * 获取输入日期的当年第1天
	 * @author dyh 2010-12-31
	 * @param date yyyy-mm-dd
	 * @return
	 */
	public final static String getFirstDayInThisYear(String date) {
		if (date == null || date.length() != 10)
			return "";
		return date.substring(0, 4) + "-01-01";
	}

	/**
	 * 输入X年第Y月，输出起始日期
	 * @author dyh 2010-03-31
	 * @param year 年份
	 * @prama monthInYear 第Y月
	 * @param dates 输出起始日期
	 * @return
	 */
	public final static void getDayByMonthInYear(int year, int monthInYear, String dates[]) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		Calendar c = Calendar.getInstance();
		c.setFirstDayOfWeek(Calendar.MONDAY);
		c.set(Calendar.YEAR, year);
		c.set(Calendar.MONTH, monthInYear - 1);
		c.set(Calendar.DAY_OF_MONTH, 1);
		dates[0] = df.format(c.getTime());

		c.set(Calendar.YEAR, year);
		c.set(Calendar.MONTH, monthInYear);
		c.set(Calendar.DAY_OF_MONTH, 1);
		c.add(Calendar.DAY_OF_MONTH, -1);
		dates[1] = df.format(c.getTime());
	}

	/**
	 * 获取输入日期的上月同一日
	 * @author dyh 2010-03-21
	 * @param date yyyy-mm-dd
	 * @return
	 */
	public final static String getSameDayInLastMonth(String date) {
		if (date == null || date.length() != 10)
			return "";
		String lastDay = "";
		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(df.parse(date));
			calendar.add(Calendar.MONTH, -1);
			lastDay = df.format(calendar.getTime());
		} catch (Exception e) {
		}
		return lastDay;
	}

	/**
	 * 按DateFormat格式返回今天
	 * @author dyh 2009-10-24
	 * @param DateFormat SimpleDateFormat格式
	 * @return 按DateFormat格式返回今天
	 */
	public final static String getToday(String DateFormat) {
		Date date = new Date();
		SimpleDateFormat df = new SimpleDateFormat(DateFormat);
		return df.format(date);
	}

	/**
	 * 输入Date，输出YYYY-MM-dd
	 * @author dyh 2009-10-24
	 * @param date YYYY-MM-DD
	 * @return YYYY-MM-dd
	 */
	public final static String getDate(Date date) {
		if (date == null) {
			return "";
		}
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		return df.format(date);
	}

	/**
	 * 输入Date，按DateFormat格式输出日期
	 * @author dyh 2009-10-24
	 * @param date
	 * @param DateFormat SimpleDateFormat格式
	 * @return SimpleDateFormat格式的日期
	 */
	public final static String getDate(Date date, String DateFormat) {
		if (date == null) {
			return "";
		}
		SimpleDateFormat df = new SimpleDateFormat(DateFormat);
		return df.format(date);
	}

	/**
	 * 获取上个月的今天
	 * @author dyh 2009-10-24
	 * @param date
	 * @return YYYY-MM-dd
	 */
	public final static String getDayInLastMonth() {
		Calendar c = Calendar.getInstance();
		c.add(Calendar.MONTH, -1);
		return getDate(c.getTime());
	}

	/**
	 * 获取前七日的今天
	 * @author dyh 2009-10-24
	 * @param date
	 * @return YYYY-MM-dd
	 */
	public final static String getDayInLastWeek() {
		Calendar c = Calendar.getInstance();
		c.add(Calendar.WEEK_OF_YEAR, -1);
		return getDate(c.getTime());
	}

	/**
	 * 获取今后七日
	 * @author dyh 2009-11-24
	 * @param date
	 * @return YYYY-MM-dd
	 */
	public final static String getDayInNextWeek() {
		Calendar c = Calendar.getInstance();
		c.add(Calendar.WEEK_OF_YEAR, 1);
		return getDate(c.getTime());
	}

	/**
	 * 获取离days天的年月日
	 * @author dyh 2009-10-24
	 * @param days 负数表示历史日期，正数表示未来日期
	 * @return YYYY-MM-dd
	 */
	public final static String getDate(int days) {
		Calendar c = Calendar.getInstance();
		c.add(Calendar.DAY_OF_YEAR, days);
		return getDate(c.getTime());
	}

	/**
	 * 获取输入日期过去days天的年月日
	 * @author dyh 2010-03-21
	 * @param days 负数表示历史日期，正数表示未来日期
	 * @return YYYY-MM-dd
	 */
	public final static String getDate(int days, String date) {
		if (date == null || date.length() != 10)
			return "";
		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Calendar c = Calendar.getInstance();
			c.setTime(df.parse(date));
			c.add(Calendar.DAY_OF_YEAR, days);
			date = df.format(c.getTime());
		} catch (Exception e) {
		}
		return date;
	}

	/**
	 * 获取第二天(日期)
	 * @author dyh 2009-10-24
	 * @param date 当前日期(YYYY-MM-DD)
	 * @return 第二天日期(YYYY-MM-DD)
	 */
	public final static String getTomorrow(String date) {
		if (date == null || date.length() != 10)
			return "";
		String nextDay = "";
		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(df.parse(date));
			calendar.add(Calendar.DAY_OF_YEAR, 1);
			nextDay = df.format(calendar.getTime());
		} catch (Exception e) {
		}
		return nextDay;
	}

	/**
	 * 获取前一天(日期)
	 * @author dyh 2009-10-24
	 * @param date 当前日期(YYYY-MM-DD)
	 * @return 前一天日期(YYYY-MM-DD)
	 */
	public final static String getYesterday(String date) {
		if (date == null || date.length() != 10)
			return "";
		String lastDay = "";
		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(df.parse(date));
			calendar.add(Calendar.DAY_OF_YEAR, -1);
			lastDay = df.format(calendar.getTime());
		} catch (Exception e) {
		}
		return lastDay;
	}

	/**
	 * 获取前一天日期（YYYY年MM月DD日）
	 * @author YOUCL 2011-1-14
	 * @return
	 */
	public final static String getYesterdayInCN() {
		return getYesterday(getToday());
	}

	/**
	 * 获取明天(日期)
	 * @author dyh 2009-10-24
	 * @return 明天日期(YYYY-MM-DD)
	 */
	public final static String getTomorrow() {
		return getDate(1);
	}

	/**
	 * 获取昨天(日期)
	 * @author dyh 2009-10-24
	 * @return 昨天日期(YYYY-MM-DD)
	 */
	public final static String getYesterday() {
		return getDate(-1);
	}

	/**
	 * 获取两个日期相隔天数
	 * @author dyh 2010-08-05
	 * @param startdate 开始日期YYYY-MM-DD
	 * @param enddate 结束日期YYYY-MM-DD
	 * @return 两个日期相隔天数
	 */
	public final static int getDayInterval(String startdate, String enddate) {
		int interval = 0;
		if (!isStrNull(startdate) && !isStrNull(enddate)) {
			try {
				SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
				Date d1 = df.parse(startdate);
				Date d2 = df.parse(enddate);
				long tmp = d2.getTime() - d1.getTime();
				interval = (int) (tmp / 86400000);
			} catch (Exception e) {
			}
		}
		return interval;
	}

	/**
	 * 输入YYYY-MM-DD，输出YYYY年M月D日
	 * @author dyh 2009-10-24
	 * @param date YYYY-MM-DD
	 * @return YYYY年M月D日
	 */
	public final static String getDateInCN(String date) {
		if (date == null || date.length() != 10)
			return "";
		return date.substring(0, 4) + "年" + getRealNumber(date.substring(5, 7)) + "月" + getRealNumber(date.substring(8, 10)) + "日";
	}

	/**
	 * 输入YYYY-MM-DD，输出M月D日
	 * @author dyh 2010-03-24
	 * @param date YYYY-MM-DD
	 * @return M年D日
	 */
	public final static String getDateInCNNoYear(String date) {
		if (date == null || date.length() != 10)
			return "";
		return getRealNumber(date.substring(5, 7)) + "月" + getRealNumber(date.substring(8, 10)) + "日";
	}

	/**
	 * 输入起止日期，如果起始日相同，则输出开始日期；如果同年，则输出：YYYY年M月D日-M月D日；如果不同年，则输出YYYY年M月D日-YYYY年M月D日
	 * @author dyh 2009-10-24
	 * @param startdate YYYY-MM-DD
	 * @param enddate YYYY-MM-DD
	 * @return YYYY年M年D日
	 */
	public final static String getStartAndEndDate(String startdate, String enddate) {
		return getStartAndEndDate(startdate, enddate, true, true);
	}

	/**
	 * 输入起止日期，根据年月日相同情况，分别显示最少的信息。
	 * @author dyh 2011-09-16
	 * @param startdate YYYY-MM-DD
	 * @param enddate YYYY-MM-DD
	 * @return YYYY年M年D日
	 */
	public final static String getStartAndEndDateInMonth(String startdate, String enddate) {
		return getStartAndEndDate(startdate, enddate, false, false);
	}

	/**
	 * 输入起止日期，根据年月日相同情况，分别显示最少的信息。比如：年相同，则不显示年。但无论如何至少显示月份
	 * @author dyh 2011-09-16
	 * @param startdate YYYY-MM-DD
	 * @param enddate YYYY-MM-DD
	 * @return YYYY年M年D日
	 */
	public final static String getStartAndEndDateInShort(String startdate, String enddate) {
		return getStartAndEndDate(startdate, enddate, false, true);
	}

	/**
	 * 输入起止日期，根据年月日相同情况，合并相同的年月日，分别显示最少的信息。比如：年相同，则不显示年
	 * @author dyh 2011-09-16
	 * @param startdate YYYY-MM-DD
	 * @param enddate YYYY-MM-DD
	 * @param showYear 如果起止日期年相同，是否显示年
	 * @param showMonth 如果起止日期年相同且月相同，是否显示月
	 * @return YYYY年M年D日
	 */
	public final static String getStartAndEndDate(String startdate, String enddate, boolean showYear, boolean showMonth) {
		if (startdate == null || enddate == null || startdate.length() != 10 || enddate.length() != 10)
			return "";
		int startyear = MyFormat.formatInt(startdate.substring(0, 4), 0);
		int startmonth = MyFormat.formatInt(startdate.substring(5, 7), 0);
		int startday = MyFormat.formatInt(startdate.substring(8), 0);
		int endyear = MyFormat.formatInt(enddate.substring(0, 4), 0);
		int endmonth = MyFormat.formatInt(enddate.substring(5, 7), 0);
		int endday = MyFormat.formatInt(enddate.substring(8), 0);
		StringBuilder dateOK = new StringBuilder();
		if (startyear == endyear) {// 如果年相同
			if (showYear) {
				dateOK.append(String.valueOf(startyear));
				dateOK.append("年");
			}
			if (startmonth == endmonth) {
				if (showMonth) {
					dateOK.append(String.valueOf(startmonth));
					dateOK.append("月");
				}
				dateOK.append(String.valueOf(startday));
				if (startday == endday) {

				} else {
					dateOK.append("-");
					dateOK.append(String.valueOf(endday));
				}
				dateOK.append("日");
			} else {
				dateOK.append(String.valueOf(startmonth));
				dateOK.append("月");
				dateOK.append(String.valueOf(startday));
				dateOK.append("日-");
				dateOK.append(String.valueOf(endmonth));
				dateOK.append("月");
				dateOK.append(String.valueOf(endday));
				dateOK.append("日");
			}
		} else {
			dateOK.append(String.valueOf(startyear));
			dateOK.append("年");
			dateOK.append(String.valueOf(startmonth));
			dateOK.append("月");
			dateOK.append(String.valueOf(startday));
			dateOK.append("日-");
			dateOK.append(String.valueOf(endyear));
			dateOK.append("年");
			dateOK.append(String.valueOf(endmonth));
			dateOK.append("月");
			dateOK.append(String.valueOf(endday));
			dateOK.append("日");
		}
		return dateOK.toString();
	}

	/**
	 * 输入起止日期，如果起始日相同，则输出开始日期；如果同年，则输出：YYYY年M月D日0时-M月D日24时；如果不同年，则输出YYYY年M月D日0时-YYYY年M月D日24时
	 * @author dyh 2010-08-21
	 * @param startdate YYYY-MM-DD
	 * @param enddate YYYY-MM-DD
	 * @return YYYY年M年D日
	 */
	public final static String getValidDate(String startdate, String enddate) {
		String date = getStartAndEndDate(startdate, enddate);
		String validdate = "";
		if (!isStrNull(date)) {
			int index = date.indexOf("-");
			if (index >= 0) {
				validdate = date.substring(0, index) + "0时-" + date.substring(index + 1) + "24时";
			} else {
				validdate = date + "0时-24时";
			}
		}
		return validdate;
	}

	/**
	 * 规格化日期：输入long，输出YYYY-MM-DD hh:mm:ss
	 * @author dyh 2010-07-16
	 * @param date 时间值
	 * @return YYYY-MM-DD hh:mm:ss
	 */
	public static String long2DateStr(long d) {
		Date date = new java.util.Date(d);
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return df.format(date);
	}

	// 检查时间格式是否正确
	public static boolean checkDate(String strDate, String pattern) {
		boolean ok = false;
		if (strDate != null && strDate.length() >= pattern.length()) {
			try {
				java.text.SimpleDateFormat df = new java.text.SimpleDateFormat(pattern);
				df.setLenient(false);
				df.parse(strDate);
				ok = true;
			} catch (Exception e) {
				System.out.println("Common.java(checkDate) error");
			}
		}
		return ok;
	}

	/**
	 * 将YYYYMMDD格式化为YYYY-MM-DD，其中“-”可自定义
	 * @param strDate YYYYMMDD
	 * @param pattern 间隔符：-，或中文；否则原样返回
	 * @return
	 */
	public static String formatDate(String strDate, String pattern) {
		if ("-".equals(pattern))
			return strDate.substring(0, 4) + "-" + strDate.substring(4, 6) + "-" + strDate.substring(6, 8);
		else if ("年月日".equals(pattern)) {
			String tmp1 = strDate.substring(4, 6);
			String tmp2 = strDate.substring(6, 8);
			return strDate.substring(0, 4) + "年" + (tmp1.startsWith("0") ? tmp1.substring(1) : tmp1) + "月"
					+ (tmp2.startsWith("0") ? tmp2.substring(1) : tmp2) + "日";
		} else
			return strDate;
	}

	/******************* 1.2 日期方法结束：日 ***************************/

	/******************* 1.3 日期方法开始：周 ***************************/
	/**
	 * 获取当前日期的周数
	 * @author dyh 2010-03-31
	 * @return
	 */
	public final static int getWeekInYear() {
		Calendar c = Calendar.getInstance();
		c.setFirstDayOfWeek(Calendar.MONDAY);
		return c.get(Calendar.WEEK_OF_YEAR);
	}

	/**
	 * 输入X年第Y周，输出起止日期
	 * @author dyh 2010-03-31
	 * @param year 年份
	 * @prama weekInYear 第Y周
	 * @return 起止日期
	 */
	public final static String[] getWeekInYear(int year, int weekInYear) {
		String dates[] = { "", "" };
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		Calendar c = Calendar.getInstance();
		c.setFirstDayOfWeek(Calendar.MONDAY);
		c.set(Calendar.YEAR, year);
		c.set(year, 0, 1);
		int firstday = c.get(Calendar.DAY_OF_WEEK);
		c.set(Calendar.DAY_OF_YEAR, (7 - firstday + 3) + 7 * (weekInYear - 2));
		dates[0] = df.format(c.getTime());
		c.set(Calendar.YEAR, year);
		c.set(Calendar.DAY_OF_YEAR, (7 - firstday + 2) + 7 * (weekInYear - 1));
		dates[1] = df.format(c.getTime());
		return dates;
	}

	/**
	 * 输入今天所在周的周一和周日
	 * @author 孙汉斌 2011-11-07
	 * @return 起止日期
	 */
	public static String[] getWeek() {
		return getWeek(null, 0);
	}

	/**
	 * 输入日期输出该日期所在周的周一和周日
	 * @author 孙汉斌 2011-11-07
	 * @param date
	 * @return 起止日期
	 */
	public static String[] getWeek(String date) {
		return getWeek(date, 0);
	}

	/**
	 * 输入周次,输出今天对应周次的周一与周日。
	 * @author 孙汉斌 2011-11-09
	 * @param week 距离本周的周数。0表示本周，1表示下1周，-1表示上1周，依次类推
	 * @return 起止日期
	 */
	public static String[] getWeek(int week) {
		return getWeek(null, week);
	}

	/**
	 * 输入日期,周次,输出对应日期对应周次的周一与周日。若日期为空,则默认为当天
	 * @author 孙汉斌 2011-11-09
	 * @param date 输入日期(缺省值为今天)
	 * @param week 距离输入日期所在周的周数。0表示本周，1表示下1周，-1表示上1周，依次类推
	 * @return 起止日期
	 */
	public static String[] getWeek(String date, int week) {
		String dates[] = { "", "" };
		if (MyFormat.isStrNull(date))
			date = MyFormat.getToday();
		try {
			SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Date formatdate = df.parse(date);
			Calendar c = Calendar.getInstance();
			c.setFirstDayOfWeek(Calendar.MONDAY);// 设置星期首日为周一
			c.setTime(formatdate);// 传入日期值
			c.add(Calendar.WEEK_OF_MONTH, week);// 传入周次
			c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
			String startdate = df.format(c.getTime());
			c.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
			String enddate = df.format(c.getTime());
			dates[0] = startdate;
			dates[1] = enddate;
		} catch (Exception e) {
		}
		return dates;
	}

	/**
	 * 判断今日是否是周末
	 * @author dyh 2010-03-22
	 * @param true：周末,false：非周末
	 * @return
	 */
	public static boolean TodayIsWeekend() {
		Calendar calendar = Calendar.getInstance();
		int day = calendar.get(Calendar.DAY_OF_WEEK);
		return (day == 1 || day == 7);
	}

	/**
	 * 获取今日是周几
	 * @author dyh 2011-10-25
	 * @return
	 */
	public static int getWeekDay() {
		Calendar c = Calendar.getInstance();
		return c.get(Calendar.DAY_OF_WEEK);
	}

	/**
	 * 检测是否在设置的星期时间内，比如周一10点到周二17点
	 * @author dyh 2011-11-14
	 * @return
	 */
	public static boolean inWeekDay(int firstDay, int firstTime, int lastDay, int lastTime) {
		boolean ok = false;
		Calendar now = Calendar.getInstance();
		int weekday = now.get(Calendar.DAY_OF_WEEK);// 今日
		if (weekday >= firstDay && weekday <= lastDay) {
			int hour = now.get(Calendar.HOUR_OF_DAY);
			if ((weekday == firstDay && hour >= firstTime) || (weekday == lastDay && hour < lastTime)) {
				ok = true;
			}
		}
		return ok;
	}

	/**
	 * 获取未来N周的起止日期集合
	 * @author dyh 2011-11-14
	 * @param weekcount 未来N周
	 * @return 未来N周起止日期集合
	 */
	public static String[][] getWeeks(int weekcount) {
		if (weekcount <= 0)
			weekcount = 1;
		String dates[][] = new String[weekcount][2];
		for (int i = 1; i <= weekcount; i++) {
			dates[i - 1] = getWeek(i);
		}
		return dates;
	}

	/**
	 * 获取输入日期开始的N周的起止日期集合
	 * @author dyh 2011-11-14
	 * @param firstdate 首日
	 * @param weekcount 未来N周
	 * @return 未来N周起止日期集合
	 */
	public static String[][] getWeeks(String firstdate, int weekcount) {
		if (weekcount <= 0)
			weekcount = 1;
		String dates[][] = new String[weekcount][2];
		for (int i = 0; i < weekcount; i++) {
			dates[i] = getWeek(firstdate, i);
		}
		return dates;
	}

	/******************* 1.3 日期方法结束：周 ***************************/

	/******************* 1.4 日期方法开始：月 ***************************/
	/**
	 * 获取本月
	 * @author dyh 2009-10-24
	 * @return
	 */
	public final static int getMonth() {
		Date date = new Date();
		SimpleDateFormat df = new SimpleDateFormat("MM");
		String month = df.format(date);
		return Integer.parseInt(month);
	}

	/**
	 * 输入日期，输出月份
	 * @author dyh 2011-01-18
	 * @param date 日期(YYYY-MM-DD)
	 * @return
	 */
	public final static String getMonth(String date) {
		return date.substring(0, 7);
	}

	/**
	 * 输入日期，输出该日为第几月
	 * @author dyh 2011-01-18
	 * @param date 日期(YYYY-MM-DD)
	 * @return
	 */
	public final static int getMonthInt(String date) {
		return MyFormat.formatInt(date.substring(5, 7));
	}

	/**
	 * 输入年和月，输出YYYY-MM
	 * @author dyh 2011-08-04
	 * @param date YYYY-MM
	 * @return YYYY年M月
	 */
	public final static String getMonth(int year, int month) {
		return year + "-" + getFixedNumber(month, 2);
	}

	/**
	 * 输入起始月份，输出月份列表
	 * @author dyh 2011-08-04
	 * @param startmonth YYYY-MM
	 * @param endmonth YYYY-MM
	 * @return 月份列表
	 */
	public final static Map<String, String> getMonth(String startmonth, String endmonth) {
		Map<String, String> hMonth = new LinkedHashMap<String, String>();
		int year_start = getYearInt(startmonth);
		int month_start = getMonthInt(startmonth);
		int year_end = getYearInt(endmonth);
		int month_end = getMonthInt(endmonth);

		int year = 0;
		int month = 0;
		int month_max = 12;
		String monthok = "";
		for (year = year_start, month = month_start; year <= year_end; year++) {
			if (year > year_start) {
				month = 1;
			}
			if (year == year_end) {
				month_max = month_end;
			} else {
				month_max = 12;
			}
			for (; month <= month_max; month++) {
				monthok = MyFormat.getMonth(year, month);
				hMonth.put(monthok, MyFormat.getMonthInCN(monthok));
			}
		}
		return hMonth;
	}

	/**
	 * 获取输入月份或日期的上一月
	 * @author dyh 2011-09-16
	 * @param month yyyy-mm
	 * @return
	 */
	public final static String getLastMonth(String month) {
		if (month == null)
			return "";
		String date = "";
		if (month.length() == 10) {
			date = month;
		} else if (month.length() == 7) {
			date = month + "-01";
		} else {
			return "";
		}
		return MyFormat.getFirstDayInLastMonth(date).substring(0, 7);
	}

	/**
	 * 获取输入月份或日期的上一月
	 * @author dyh 2011-09-16
	 * @param month yyyy-mm
	 * @return
	 */
	public final static String getLastMonthInCN(String month) {
		return getMonthInCN(getLastMonth(month));
	}

	/**
	 * 输入YYYY-MM，输出YYYY年M月
	 * @author dyh 2011-08-04
	 * @param date YYYY-MM
	 * @return YYYY年M月
	 */
	public final static String getMonthInCN(String month) {
		if (month == null || month.length() != 7)
			return "";
		return month.substring(0, 4) + "年" + getRealNumber(month.substring(5)) + "月";
	}

	/**
	 * 输入起止月份，输出这两个月份间的全部日数(比如输入2011-08和2011-10，则输出8月、9月和10月的天数，为31+30+31=92天)
	 * @author dyh 2011-08-04
	 * @param startmonth YYYY-MM
	 * @param endmonth YYYY-MM
	 * @return
	 */
	public final static int getDayBetweenMonths(String startmonth, String endmonth) {
		return getDayInterval(startmonth + "-01", getLastDayInThisMonth(endmonth + "-01")) + 1;
	}

	/******************* 1.4 日期方法结束：月 ***************************/

	/******************* 1.5 日期方法开始：季 ***************************/

	/**
	 * 输入日期，输出该日为本季度第几天
	 * @author dyh 2011-01-18
	 * @param date 日期(YYYY-MM-DD)
	 * @return
	 */
	public final static int getDaysInQuarter(String date) {
		boolean isLeapYear = MyFormat.isLeapYear(MyFormat.getYear(date));
		int Year[] = isLeapYear ? MyParam.DAYS_IN_LEAPYEAR : MyParam.DAYS_IN_YEAR;
		int quarter = MyFormat.getQuarter(date);
		int startmonth = (quarter - 1) * 3;
		int endmonth = MyFormat.getMonthInt(date) - 1;
		int days = 0;
		for (int i = startmonth; i >= 0 && i < 12 && i < endmonth; i++) {
			days += Year[i];
		}
		return days + MyFormat.getDay(date);
	}

	/**
	 * 输入年份和第几季度，输出该季度共有多少天
	 * @author dyh 2011-01-18
	 * @param year 年份(YYYY)
	 * @param quarter 第几个季度
	 * @return
	 */
	public final static int getDaysInQuarter(String year, int quarter) {
		boolean isLeapYear = MyFormat.isLeapYear(year);
		int Year[] = isLeapYear ? MyParam.DAYS_IN_LEAPYEAR : MyParam.DAYS_IN_YEAR;
		int startmonth = (quarter - 1) * 3 + 1;
		int endmonth = startmonth + 2;
		int days = 0;
		for (int i = startmonth - 1; i < endmonth; i++) {
			days += Year[i];
		}
		return days;
	}

	/**
	 * 输入日期，输出该日为第几季度
	 * @author dyh 2011-01-18
	 * @param date 日期(YYYY-MM-DD)
	 * @return
	 */
	public final static int getQuarter(String date) {
		if (MyFormat.isStrNull(date) || date.length() != 10)
			return MyConstant.INT_NULL;
		else {
			return (MyFormat.getMonthInt(date) - 1) / 3 + 1;
		}
	}

	/******************* 1.5 日期方法结束：季 ***************************/

	/******************* 1.6 日期方法开始：年 ***************************/
	/**
	 * 获取今年
	 * @author dyh 2009-10-24
	 * @return YYYY
	 */
	public final static int getYear() {
		Date date = new Date();
		SimpleDateFormat df = new SimpleDateFormat("yyyy");
		String year = df.format(date);
		return Integer.parseInt(year);
	}

	/**
	 * 输入年份位数(4位或2位)，输出今年
	 * @author dyh 2009-10-24
	 * @param n (4位或2位),默认4位
	 * @return 根据n位数(4位或2位)输出今年
	 */
	public final static String getYear(int n) {
		if (!(n == 2 || n == 4))
			n = 4;
		Date date = new Date();
		String year = "";
		for (int i = 0; i < n; i++)
			year += "y";
		SimpleDateFormat df = new SimpleDateFormat(year);
		return df.format(date);
	}

	/**
	 * 输入日期，取出年份
	 * @author dyh 2011-01-24
	 * @param date YYYY-MM-DD或YYYY-MM
	 * @return 年份
	 */
	public final static String getYear(String date) {
		return date.substring(0, 4);
	}

	/**
	 * 输入日期，取出年份
	 * @author dyh 2011-01-24
	 * @param date YYYY-MM-DD或YYYY-MM
	 * @return 年份
	 */
	public final static int getYearInt(String date) {
		return MyFormat.formatInt(date.substring(0, 4));
	}

	/**
	 * 判断是否为闰年
	 * @author dyh 2011-01-18
	 * @param year(YYYY)
	 * @return
	 */
	public final static boolean isLeapYear(int year) {
		return (year % 4 == 0 && year % 100 != 0 || year % 400 == 0);
	}

	/**
	 * 判断是否为闰年
	 * @author dyh 2011-01-18
	 * @param year(YYYY)
	 * @return
	 */
	public final static boolean isLeapYear(String year) {
		return isLeapYear(MyFormat.formatInt(year));
	}

	/**
	 * 输入年份，输出该年全年周数
	 * @author dyh 2010-03-31
	 * @param year 年份
	 * @return
	 */
	public final static int getWeeksByYear(int year) {
		Calendar c = Calendar.getInstance();
		c.setFirstDayOfWeek(Calendar.MONDAY);
		c.set(year + 1, 0, 1);
		c.add(Calendar.DAY_OF_MONTH, -1);
		return c.getMaximum(Calendar.WEEK_OF_YEAR);
	}

	/**
	 * 输入年份，输出该年全年天数
	 * @author dyh 2010-04-28
	 * @param year 年份
	 * @return
	 */
	public final static int getDaysInFullYear(int year) {
		Calendar c = Calendar.getInstance();
		c.set(year, Calendar.DECEMBER, 31);
		return c.get(Calendar.DAY_OF_YEAR);
	}

	/**
	 * 输入年份，输出该年全年天数
	 * @author dyh 2010-04-28
	 * @param year 年份
	 * @return
	 */
	public final static int getDaysInFullYear(String year) {
		return getDaysInFullYear(MyFormat.formatInt(year));
	}

	/**
	 * 输入日期，输出该日为一年中的第几天
	 * @author dyh 2011-01-18
	 * @param date 日期(YYYY-MM-DD)
	 * @return
	 */
	public final static int getDaysInYear(String date) {
		Calendar c = Calendar.getInstance();
		c.set(MyFormat.getYearInt(date), MyFormat.getMonthInt(date) - 1, MyFormat.getDay(date));
		return c.get(Calendar.DAY_OF_YEAR);
	}

	/**
	 * 获取去年年份
	 * @author YOUCL 2011-1-18
	 * @return
	 */
	public final static String getLastYear() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR) - 1);
		SimpleDateFormat df = new SimpleDateFormat("yyyy");
		return df.format(calendar.getTime());
	}

	/**
	 * 获取指定年月按月统计的起止日期二维数组,只能统计相邻两年 如输入2010,1,2010,2返回{{'2010-01-01','2010-01-31'},{'2010-02-01','2010-02-28'}}
	 * @author ycl 2010-05-28
	 * @param startyear
	 * @param startmonth
	 * @param endyear
	 * @param endmonth
	 * @return
	 */
	public final static String[][] getStartEndDayInYear(int startyear, int startmonth, int endyear, int endmonth) {
		String arr[][] = null;
		int row = getSpaceMonthInYear(startyear, startmonth, endyear, endmonth);
		arr = new String[row][];
		int step = 0;
		if (endyear > startyear) {
			for (int i = startmonth; i <= 12; i++) {
				String dates[] = new String[2];
				getDayByMonthInYear(startyear, i, dates);
				arr[step] = dates;
				step++;
			}
			for (int i = 1; i <= endmonth; i++) {
				String dates[] = new String[2];
				getDayByMonthInYear(endyear, i, dates);
				arr[step] = dates;
				step++;
			}
		} else {
			for (int i = startmonth; i <= endmonth; i++) {
				String dates[] = new String[2];
				getDayByMonthInYear(startyear, i, dates);
				arr[step] = dates;
				step++;
			}
		}
		return arr;
	}

	/**
	 * 获取指定年月起止月份数组,只能统计相邻两年 如输入2010,1,2010,2返回{'2010-1','2010-2'}
	 * @author ycl 2010-05-28
	 * @param startyear
	 * @param startmonth
	 * @param endyear
	 * @param endmonth
	 * @return
	 */
	public final static String[] getStartEndMonthInYear(int startyear, int startmonth, int endyear, int endmonth) {
		String month[] = null;
		int row = getSpaceMonthInYear(startyear, startmonth, endyear, endmonth);
		month = new String[row];
		int step = 0;
		if (endyear > startyear) {
			for (int i = startmonth; i <= 12; i++) {
				month[step] = startyear + "-" + i;
				step++;
			}
			for (int i = 1; i <= endmonth; i++) {
				month[step] = endyear + "-" + i;
				step++;
			}
		} else {
			for (int i = startmonth; i <= endmonth; i++) {
				month[step] = startyear + "-" + i;
				step++;
			}
		}
		return month;
	}

	/**
	 * 获取指定年月相差的月份数,(如输入2009,1,2010,3返回15)
	 * @author ycl 2010-05-28
	 * @param startyear
	 * @param startmonth
	 * @param endyear
	 * @param endmonth
	 * @return
	 */
	public final static int getSpaceMonthInYear(int startyear, int startmonth, int endyear, int endmonth) {
		int space = 0;
		if (endyear > startyear)
			space += (endyear - startyear) * 12;
		space += (endmonth - startmonth) + 1;
		return space;
	}

	/**
	 * 获取指定年月第一日,yyyy-MM-dd(如输入2010,1,返回2010-01-01)
	 * @author ycl 2010-05-28
	 * @param year 年份
	 * @prama monthInYear 第Y月
	 * @return
	 */
	public final static String getFirstDayByMonthInYear(int year, int monthInYear) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, year);
		c.set(Calendar.MONTH, monthInYear - 1);
		c.set(Calendar.DAY_OF_MONTH, 1);
		return df.format(c.getTime());
	}

	/**
	 * 获取指定年月最后一日,yyyy-MM-dd(如输入2010,1,返回2010-01-31)
	 * @author ycl 2010-05-28
	 * @param year 年份
	 * @prama monthInYear 第Y月
	 * @return
	 */
	public final static String getLastDayByMonthInYear(int year, int monthInYear) {
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, year);
		c.set(Calendar.MONTH, monthInYear);
		c.set(Calendar.DAY_OF_MONTH, 1);
		c.add(Calendar.DAY_OF_MONTH, -1);
		return df.format(c.getTime());
	}

	/******************* 1.6 日期方法结束：年 ***************************/

	/******************* 1. 日期方法结束 ***************************/

	/******************* 2. 格式化数据类型方法开始 ***********************/

	/******************* 2.1 格式化数据类型方法开始：String ***********************/

	/**
	 * 输入文本s，如果不为null，则输出s；如果为null，则输出sub
	 * @author dyh 2010-06-04
	 * @param s 要格式化的字符串
	 * @param sub 替代的字符串
	 * @return 如果不为null，则输出s；如果为null，则输出sub
	 */
	public static String formatStr(Object s, String sub) {
		return isStrNull(s) ? sub : s.toString();
	}

	/**
	 * 输入文本s，如果不为null，则输出s；如果为null，则输出""
	 * @author dyh 2010-06-04
	 * @param s 要格式化的字符串
	 * @return 如果不为null，则输出s；如果为null，则输出""
	 */
	public static String formatStr(Object s) {
		return formatStr(s, "");
	}

	/**
	 * 查找字符串中find的数量
	 * @author dyh 2011-2-6
	 * @param source 字符串
	 * @param find 要查找的字符串
	 * @return find数量
	 */
	public static int matchStrCount(String source, String find) {
		if (MyFormat.isStrNull(source) || MyFormat.isStrNull(find))
			return 0;
		String pattern = "(" + find + "){1}";
		Pattern p = Pattern.compile(pattern);
		Matcher m = p.matcher(source);
		int i = 0;
		while (m.find()) {
			i++;
		}
		return i;
	}

	/**
	 * 将两个路径拼接
	 * @author dyh 2011-2-6
	 * @param path1
	 * @param path2
	 * @return
	 */
	public static String joinPath(String path1, String path2) {
		path1 = MyFormat.formatStr(path1);
		path2 = MyFormat.formatStr(path2);
		if (path1.endsWith("/") || path1.endsWith("\\")) {
			if (path2.startsWith("/") || path2.startsWith("\\")) {
				path2 = path2.substring(1);
			}
		} else {
			if (!(path2.startsWith("/") || path2.startsWith("\\"))) {
				path2 = "/" + path2;
			}
		}
		return path1 + path2;
	}

	/**
	 * 按规定字数输出字符串，超长则使用省略号...
	 * @author dyh 2009-10-24
	 * @param length 字符数(一个中文为2个字符)
	 * @param str 需要限制长度的字符串
	 * @return 按length输出字符串，超长则使用省略号...
	 */
	public final static String getLimitedString(int length, String str) {
		if (str == null || length == 0)
			return "";
		StringBuilder buff = new StringBuilder(str);
		int buffLen = buff.length();// buff长度
		int realLen = 0;// 真实字符数(中文为2个字符)
		int tmpLen = 0;// 真实字符数(中文为2个字符)
		int CharLen[] = new int[3];// 最后三个字符的长度
		int tmpCharLen = 0;// 最后一个字的长度
		String stmp;
		int i = 0;
		for (; i < buffLen; i++) {
			stmp = buff.substring(i, i + 1);
			try {
				stmp = new String(stmp.getBytes("UTF-8"));
			} catch (Exception e) {

			}
			if (stmp.getBytes().length > 1)
				tmpCharLen = 2;// 双字节字符
			else
				tmpCharLen = 1;// 单字符
			tmpLen = realLen + tmpCharLen;
			if (tmpLen > length)
				break;
			CharLen[2] = CharLen[1];
			CharLen[1] = CharLen[0];
			CharLen[0] = tmpCharLen;
			realLen += tmpCharLen;
		}
		if (i == buffLen)// 如果str真实长度在length内,则不用添加省略号
			return str;
		else {
			int l = 0, j = 0, LenOK = 0;
			for (; j < CharLen.length && CharLen[j] != 0; j++) {
				l += CharLen[j];
				LenOK = (realLen - l);
				if ((realLen - l) <= (length - 3))
					break;
			}
			String point = "";
			for (int k = 0; k < length - LenOK; k++) {
				point += ".";
			}

			return (i - (j + 1)) <= 0 ? point : (buff.substring(0, i - (j + 1)) + point);
		}
	}

	/**
	 * 按规定字数输出字符串，超长时截断，但不用省略号
	 * @author dyh 2009-10-24
	 * @param length 字符数(一个中文为2个字符)
	 * @param str 需要限制长度的字符串
	 * @return 按length输出字符串，超长时截断，但不用省略号
	 */
	public final static String getLimitedStringNoStop(int length, String str) {
		if (str == null || length == 0)
			return "";
		StringBuilder buff = new StringBuilder(str);
		int buffLen = buff.length();// buff长度
		int realLen = 0;// 真实字符数(中文为2个字符)
		int tmpCharLen = 0;// 字的长度
		String stmp;
		int i = 0;
		for (; i < buffLen; i++) {
			stmp = buff.substring(i, i + 1);
			try {
				stmp = new String(stmp.getBytes("UTF-8"));
			} catch (Exception e) {

			}
			if (stmp.getBytes().length > 1)
				tmpCharLen = 2;// 双字节字符
			else
				tmpCharLen = 1;// 单字符
			if ((realLen + tmpCharLen) > length)
				break;
			realLen += tmpCharLen;
		}
		return buff.substring(0, i);
	}

	/**
	 * 获取字符串长度(一个中文为2个字符)
	 * @author dyh 2009-10-24
	 * @param str 字符串
	 * @return 字符数(一个中文为2个字符)
	 */
	public final static int getStringLength(String str) {
		if (str == null)
			return 0;

		StringBuilder buff = new StringBuilder(str);
		int length = 0;
		String stmp;
		for (int i = 0; i < buff.length(); i++) {
			stmp = buff.substring(i, i + 1);
			try {
				stmp = new String(stmp.getBytes("utf-8"));
			} catch (Exception e) {

			}
			if (stmp.getBytes().length > 1) {
				length += 2;
			} else {
				length += 1;
			}
		}
		return length;
	}

	public static String convertStr(String str) {
		if (str == null) {
			str = "";
		} else {
			try {
				str = str.replaceAll("<", "&lt;");
				str = str.replaceAll(">", "&gt;");
				str = str.replaceAll("&nbsp;", "&nbsp;");
				str = str.replaceAll("\r\n", "<br>&nbsp;");
			} catch (Exception e) {
				e.printStackTrace(System.err);
			}
		}
		return str;
	}

	/******************* 2.1 格式化数据类型方法结束：String ***********************/

	/******************* 2.2 格式化数据类型方法开始：int ***********************/

	/**
	 * 输入Integer对象，输出数值,如果为null，输出MyConstant.INT_NULL
	 * @author dyh 2010-12-28
	 * @param i Integer对象
	 * @return 输出数值,如果为null，输出MyConstant.INT_NULL
	 */
	public static int formatInt(Integer i) {
		return formatInt(i, MyConstant.INT_NULL);
	}

	/**
	 * 输入Integer对象，输出数值,如果为null，输出intNull
	 * @author dyh 2010-12-28
	 * @param i Integer对象
	 * @param intNull 缺省值
	 * @return 输出数值,如果为null，输出intNull
	 */
	public static int formatInt(Integer i, int intNull) {
		return i == null ? intNull : i.intValue();
	}

	/**
	 * 输入Object对象，输出int值，如果Object为null或异常情况，则输出MyConstant.INT_NULL
	 * @author dyh 2010-12-28
	 * @param o Object对象
	 * @return 输出int值，如果Object为null或异常情况，则输出MyConstant.INT_NULL
	 */
	public static int formatInt(Object o) {
		return formatInt(o, MyConstant.INT_NULL);
	}

	/**
	 * 输入Object对象，输出数值,如果为null，输出intNull
	 * @author dyh 2010-12-28
	 * @param o Object对象
	 * @param intNull 缺省值
	 * @return 输出数值,如果为null，输出intNull
	 */
	public static int formatInt(Object o, int intNull) {
		int i = intNull;
		if (o != null) {
			try {
				i = Integer.parseInt(o.toString());
			} catch (Exception ex) {

			}
		}
		return i;
	}

	/**
	 * 输入N位字符串型数字，输出高位不带0的字符串型数字 如：输入“01”，则输出“1”；输入“12”，则输出“12”
	 * @author dyh 2009-10-24
	 * @param x N位字符串型数字
	 * @return 高位不带0的字符串型数字
	 */
	public final static String getRealNumber(String x) {
		String result = x;
		if (MyFormat.isStrNull(result))
			return "";
		while (result.length() > 1 && result.startsWith("0")) {
			result = result.substring(1);
			getRealNumber(result);
		}
		return result;
	}

	/**
	 * 输入数字，输出长度为n的字符串型数字（高位补0）
	 * @author dyh 2009-10-24
	 * @param x 数字
	 * @return 高位带0的字符串型数字
	 */
	public final static String getFixedNumber(int x, int n) {
		String xx = String.valueOf(x);
		int length = xx.length();
		StringBuilder s = new StringBuilder();
		for (int i = length; i < n; i++) {
			s.append("0");
		}
		s.append(xx);
		return s.toString();
	}

	/**
	 * 输入数字，输出长度为n的字符串型数字（高位补0）
	 * @author dyh 2009-10-24
	 * @param x 数字
	 * @return 高位带0的字符串型数字
	 */
	public final static String getFixedNumber(Long x, int n) {
		String xx = x + "";
		int length = xx.length();
		StringBuilder s = new StringBuilder();
		for (int i = length; i < n; i++) {
			s.append("0");
		}
		s.append(xx);
		return s.toString();
	}

	/******************* 2.2 格式化数据类型方法结束：int ***********************/

	/******************* 2.3 格式化数据类型方法开始：double ***********************/

	/**
	 * 输入Double对象，输出double值,如果为null，输出MyConstant.DOUBLE_NULL
	 * @author dyh 2010-12-28
	 * @param i Double对象
	 * @return 输出数值,如果为null，输出MyConstant.INT_NULL
	 */
	public static double formatDouble(Double i) {
		//System.out.println(formatDouble(i, MyConstant.DOUBLE_NULL));
		return formatDouble(i, MyConstant.DOUBLE_NULL);
	}

	/**
	 * 输入Double对象，输出double值,如果为null，输出dNull
	 * @author dyh 2010-12-28
	 * @param i Double对象
	 * @param dNull 缺省值
	 * @return 输出数值,如果为null，输出dNull
	 */
	public static double formatDouble(Double i, int dNull) {
		return i == null ? dNull : i.doubleValue();
	}

	/**
	 * 对double按位数进行四舍五入，返回带digit位小数
	 * @author dyh 2011-09-05
	 * @param d
	 * @param digit 小数点位数
	 * @return
	 */
	public final static double roundingDouble(double d, int digit) {
		int bit = 1;
		for (int i = 0; i < digit; i++) {
			bit *= 10;
		}
		boolean minus = d < 0;
		if (minus) {
			d = -d;
		}
		return (((long) (d * bit + 1.5)) - 1) * 1.0 / bit * (minus ? -1 : 1);
	}

	/**
	 * 规格化double，返回带bit位小数(不含逗号)
	 * @author dyh 2009-10-24
	 * @param d
	 * @param bit 小数点位数
	 * @return 00.0
	 */
	public final static String formatDouble(double d, int bit) {
		String patern = "";
		if (bit <= 0) {
			bit = 0;
			patern = "0";
		} else {
			for (int i = 0; i < bit; i++) {
				patern += "#";
			}
			patern = "0." + patern;
		}
		DecimalFormat f = new DecimalFormat(patern);
		return f.format(roundingDouble(d, bit));
	}

	/**
	 * 输入Object对象，输出double值，如果Object为null或异常情况，则输出MyConstant.DOUBLE_NULL
	 * @author dyh 2010-12-28
	 * @param o Object对象
	 * @return 输出double值，如果Object为null或异常情况，则输出MyConstant.DOUBLE_NULL
	 */
	public static double formatDouble(Object o) {
		return formatDouble(o, MyConstant.DOUBLE_NULL);
	}

	/**
	 * 输入Object对象，输出double数值,如果为null，输出dNull
	 * @author dyh 2010-12-28
	 * @param o Object对象
	 * @param dNull 缺省值
	 * @return 输出数值,如果为null，输出dNull
	 */
	public static double formatDouble(Object o, double dNull) {
		double i = dNull;
		if (o != null) {
			try {
				i = Double.parseDouble(o.toString());
			} catch (Exception ex) {

			}
		}
		return i;
	}

	/**
	 * 是否包含小数
	 * @author dyh 2009-10-24
	 * @param d 金额
	 * @return
	 */
	public final static boolean isDouble(double d) {
		return (((double) ((int) d)) != d);
	}
	/**
	 * 若为较大数值，不采用科学计数法显示，直接显示原数值
	 * @author 孙汉斌 2011-12-20
	 * @param d
	 * @return
	 */
	public final static String normalDouble(double d){
		java.text.NumberFormat nf = java.text.NumberFormat.getInstance();
		nf.setGroupingUsed(false);
		return nf.format(d);

	}

	/******************* 2.3 格式化数据类型方法结束：double ***********************/

	/******************* 2.4 格式化数据类型方法开始：boolean ***********************/
	/**
	 * 判断字符串是否为空或长度为0
	 * @author dyh 2010-07-21
	 * @param str 字符串
	 * @return 是否为空或长度为0
	 */
	public static boolean isStrNull(String str) {
		return str == null || str.length() == 0;
	}

	/**
	 * 判断字符串是否为空或长度为0
	 * @author dyh 2010-07-21
	 * @param str 字符串
	 * @return 是否为空或长度为0
	 */
	public static boolean isStrNull(Object str) {
		return str == null || str.toString().length() == 0;
	}

	/**
	 * 输入0或1，输出"是"或"否"
	 * @author dyh 2010-06-06
	 * @param flag 要格式化的字符串
	 * @return 输出"是"或"否"，如果flag为null，输出"否"
	 */
	public static String formatFlag(String flag) {
		return "1".equals(flag) ? "是" : "否";
	}

	/**
	 * 输入0或1，输出"是"或"否",如果flag为null，输出strNull
	 * @author dyh 2010-06-06
	 * @param flag 要格式化的字符串
	 * @return 输出"是"或"否"，如果flag为null，输出strNull
	 */
	public static String formatFlag(String flag, String strNull) {
		return flag == null ? strNull : ("1".equals(flag) ? "是" : "否");
	}

	/******************* 2.4 格式化数据类型方法结束：boolean ***********************/

	/******************* 2.5 格式化数据类型方法开始：percent ***********************/

	/**
	 * 两个值对比：新数据比旧数据提升或下降了N%
	 * @author dyh 2010-03-23
	 * @param olddata 旧数据
	 * @param newdata 新数据
	 * @return 经规格化后的结果
	 */
	public static String formatPercentRaise(int newdata, int olddata) {
		double rate = 0.0;
		if (newdata < 0)
			newdata = 0;
		rate = (newdata - (olddata < 0 ? 0 : olddata)) * 1.0 / (olddata <= 0 ? 1 : olddata);
		return (rate >= 0 ? MyConstant.SMS_UP : MyConstant.SMS_DOWN) + MyFormat.getPercentByInt(rate >= 0 ? rate : -rate);
	}

	/**
	 * 两个值相减：新数据比旧数据提升或下降了N个百分点
	 * @author dyh 2010-03-23
	 * @param olddata 旧数据
	 * @param newdata 新数据
	 * @return 经规格化后的结果
	 */
	public static String formatPercentSubtract(double newdata, double olddata) {
		double result = newdata - olddata;
		return (result >= 0 ? MyConstant.SMS_UP : MyConstant.SMS_DOWN) + MyFormat.getPercentByInt(result >= 0 ? result : -result);
	}

	/**
	 * 两个值占比：部分数据占总数据N%
	 * @author dyh 2010-03-23
	 * @param data 部分数据
	 * @param total 总数据
	 * @return 经规格化后的结果
	 */
	public static String getPercent(int data, int total) {
		return MyFormat.getPercent(getPercentInDouble(data, total));
	}

	/**
	 * 两个值占比：部分数据占总数据N%
	 * @author dyh 2010-03-23
	 * @param data 部分数据
	 * @param total 总数据
	 * @return 经规格化后的结果
	 */
	public static String getPercentByInt(int data, int total) {
		return MyFormat.getPercentByInt(getPercentInDouble(data, total));
	}

	/**
	 * 两个值占比：部分数据占总数据N%
	 * @author dyh 2010-03-23
	 * @param data 部分数据
	 * @param total 总数据
	 * @return 经规格化后的结果
	 */
	public static double getPercentInDouble(int data, int total) {
		if (total <= 0)
			return 0;
		if (data < 0)
			data = 0;
		return data * 1.0 / total;
	}

	/**
	 * 规格化百分数，返回整数(输入0.015，输出2)
	 * @author dyh 2010-03-17
	 * @param d 实际值
	 * @return 00
	 */
	public final static String getPercentByInt(double d) {
		DecimalFormat f = new DecimalFormat("0");
		return f.format(roundingDouble(d * 100, 0));
	}

	/**
	 * 规格化百分数，返回带一位小数金额(输入0.015，输出1.5)
	 * @author dyh 2009-10-24
	 * @param d 实际值
	 * @return 00.0
	 */
	public final static String getPercent(double d) {
		DecimalFormat f = new DecimalFormat("0.#");
		return f.format(roundingDouble(d * 100, 1));
	}

	/******************* 2.5 格式化数据类型方法结束：percent ***********************/

	/******************* 2.6 格式化数据类型方法开始：money ***********************/

	/**
	 * 规格化金额，返回带两位小数金额(可含逗号)
	 * @author dyh 2009-10-24
	 * @param d 金额
	 * @return 00.00
	 */
	public final static String getMoneyHasComma(double d) {
		DecimalFormat f = new DecimalFormat("#,##0.00");
		return f.format(roundingDouble(d, 2));
	}

	/**
	 * 规格化金额，返回带两位小数金额(可含逗号)
	 * @author dyh 2011-09-18
	 * @param d 金额
	 * @return 00.00
	 */
	public final static String getRealMoneyHasComma(double d) {
		String patern = "";
		if (isDouble(d))// 包括小数
			patern = "#,##0.00";
		else
			patern = "#,##0.##";
		DecimalFormat f = new DecimalFormat(patern);
		return f.format(roundingDouble(d, 2));
	}

	/**
	 * 规格化金额，返回带两位小数金额(不含逗号)
	 * @author dyh 2009-10-24
	 * @param d 金额
	 * @return 00.00
	 */
	public final static String getMoney(double d) {
		String patern = "";
		if (isDouble(d))// 包括小数
			patern = "0.00";
		else
			patern = "0.##";
		DecimalFormat f = new DecimalFormat(patern);
		return f.format(roundingDouble(d, 2));
	}

	/******************* 2.6 格式化数据类型方法结束：money ***********************/

	/******************* 2. 格式化数据类型方法结束 ***********************/

	/******************* 99. 控件、网页、IMEI、路径相关方法开始 ***************************/
	/**
	 * 输入地市ID(非全省)，检测该ID是否合法
	 * @author dyh 2010-09-09
	 * @param areaid
	 * @return
	 */
	public static boolean checkAreaID(int areaid) {
		return areaid > 0 && areaid < MyConstant.AREA_MAX;
	}

	/**
	 * 输入地市ID(非全省)，检测该ID是否合法
	 * @author dyh 2010-09-09
	 * @param areaid
	 * @return
	 */
	public static boolean checkAreaID(String areaid) {
		if (isStrNull(areaid))
			return false;
		else {
			return checkAreaID(Integer.parseInt(areaid));
		}
	}

	/**
	 * 获取数字输入框HTML
	 * @author dyh 2011-10-28
	 * @param name 控件名称
	 * @param type num：纯数字；currency:货币（数字和小数点）；string:数字字符串(允许首位为0)
	 * @return
	 */
	public static String getInputTag(String name, String type, String value, int size, int maxlength) {
		StringBuilder html = new StringBuilder();
		if (MyFormat.isStrNull(type)) {
			type = "num";
		} else
			type = type.toLowerCase();
		if (size <= 0 && maxlength <= 0) {
			if (size <= 0)
				size = 8;
			if (maxlength <= 0)
				maxlength = 7;
		} else {
			if (size <= 0)
				size = maxlength;
			if (maxlength <= 0)
				maxlength = size;
		}
		String onKeyPress = "";
		if ("currency".equals(type)) {
			onKeyPress = "numberOnly()";
		} else if ("string".equals(type)) {
			onKeyPress = "intOnly()";
		} else {
			onKeyPress = "intOnly()";
		}
		html.append("<input name=\"");
		html.append(name);
		html.append("\" id=\"");
		html.append(name);
		html.append("\" type=\"text\" size=\"");
		html.append(size);
		html.append("\" maxlength=\"");
		html.append(maxlength);
		html.append("\" value=\"");
		if (value != null && value.length() > 0) {
			value = value.trim();
			if ("currency".equals(type)) {
				value = MyFormat.getMoney(Double.parseDouble(value));
			} else if ("string".equals(type)) {

			} else {
				value = MyFormat.getRealNumber(value);
			}
			html.append(value);
		}
		html.append("\" onKeyPress=\"");
		html.append(onKeyPress);
		html.append("\" ");
		html.append(" style=\"ime-mode:Disabled");
		html.append("\"");
		html.append(" onbeforepaste=\"clipboardData.setData(\'text\',clipboardData.getData(\'text\').replace(/[^\\d]/g,\'\'))\" ");
		html.append("/>");
		return html.toString();
	}

	/**
	 * 获取数字输入框HTML
	 * @author dyh 2011-10-28
	 * @param name 控件名称
	 * @return
	 */
	public static String getInputTag(String name) {
		return getInputTag(name, null, null, -1, -1);
	}

	/**
	 * 输入字符串，输出带
	 * <p>
	 * 的段落HTML，用于页面显示
	 * @author dyh 2009-10-24
	 * @param str 需要格式化的字符串
	 * @return 输出带
	 *         <p>
	 *         的段落HTML
	 */
	public final static String getParagraph(String str) {
		if (str == null || str.length() == 0)
			return "<p>&nbsp;</p>";
		str = str.replaceAll("\r", "</p><p>");
		str = str.replaceAll(" ", "&nbsp");
		return "<p>" + str + "</p>";
	}

	/**
	 * 输入一个数组，输出已合并上下同类项的数组，用于JSP页面的rowspan 例如：rowspan=3，表示只处理合并前三个字段 输入以下数组content： 第0行：联合康康,A,10,xx,yy 第1行：联合康康,A,10,xx,yy 第2行：联合康康,A,20,xx,yy 第3行：联合康康,A,20,xx,yy 第4行：叶氏兄弟,A,30,xx,yy
	 * 第5行：叶氏兄弟,A,30,xx,yy 输出数组规则：从第0列开始处理，对于第i行第j列元素M[i][j]来说， 如果M[i+1][j]等于M[i][j]，则合并此列，表示此列的rowspan的元素M[i][j+1]加1： 第0行：联合康康, A, 10,xx,yy, 4, 4, 2 第1行： null,null,null,xx,yy,null,null,null 第2行：
	 * null,null, 20,xx,yy,null,null, 2 第3行： null,null,null,xx,yy,null,null,null 第4行：叶氏兄弟, A, 30,xx,yy, 2, 2, 2 第5行： null,null,null,xx,yy,null,null,null
	 * @author dyh 2009-10-24
	 * @param content 要处理的数组(此参数也为输出参数，当出现重复字段时，置为null)
	 * @param needRowspanCols 前N列需要合并同类项，如果needRowspanCols=-1，表示数组所有列都需要考虑合并
	 * @return 输出rowspan数组
	 */
	public static int[][] getRowspanArray(ArrayList<String[]> content, int needRowspanCols) {
		if (content == null)
			return null;
		int rowcount = content.size();// 行数
		if (rowcount == 0)
			return null;
		int colcount = content.get(0).length;// 列数
		if (colcount == 0)
			return null;
		if (needRowspanCols == -1 || needRowspanCols > colcount)
			needRowspanCols = colcount;
		int[][] arrRowspan = new int[rowcount][colcount];
		String[] oldRow = new String[colcount];
		int row = 0, col = 0;
		int currentRow[] = new int[colcount];
		for (String[] contentRow : content) {
			if (row == 0) {
				for (col = 0; col < needRowspanCols; col++) {
					oldRow[col] = contentRow[col];
				}
				row++;
				continue;
			}
			for (col = 0; col < needRowspanCols; col++) {
				if (oldRow[col].equals(contentRow[col])) {
					if (col > 0 && contentRow[col - 1] != null) {
						arrRowspan[currentRow[col]][col] = row - currentRow[col];
						currentRow[col] = row;
						oldRow[col] = contentRow[col];
					} else {
						if (row == (rowcount - 1))// 最后一行
							arrRowspan[currentRow[col]][col] = row - currentRow[col] + 1;
						contentRow[col] = null;
					}
				} else {
					arrRowspan[currentRow[col]][col] = row - currentRow[col];
					currentRow[col] = row;
					oldRow[col] = contentRow[col];
				}
			}
			row++;
		}
		return arrRowspan;
	}

	/**
	 * 输入一个数组，输出已合并上下同类项的表格tr和td
	 * @author dyh 2010-07-24
	 * @param content 要处理的数组,每一行
	 * @param needRowspanCols 前N列需要合并同类项，如果needRowspanCols=-1，表示数组所有列都需要考虑合并。不包括行数i字段
	 * @param trStyle tr样式(缺省值为center)
	 * @prama tdStyle td样式(可以为空)
	 * @return 输出已合并上下同类项的表格tr和td
	 */
	public static String getRowspanArray2HTML(ArrayList<String[]> content, int needRowspanCols, String trStyle, String[] tdStyle) {
		int[][] rowspan = getRowspanArray(content, needRowspanCols);
		if (rowspan == null)
			return "";
		trStyle = formatStr(trStyle, "align=\"center\"");
		boolean isCenter = (trStyle.toLowerCase().indexOf("center") >= 0);
		StringBuilder html = new StringBuilder();
		int col = 0, row = 0;
		for (String[] rows : content) {
			html.append("<tr ");
			html.append(trStyle);
			html.append("><td");
			if (!isCenter) {
				html.append(" align=\"center\"");
			}
			html.append(">");
			html.append(row + 1);
			html.append("</td>");
			for (col = 0; col < rows.length; col++) {
				if (rows[col] != null) {
					html.append("<td ");
					if (tdStyle != null) {
						html.append(formatStr(tdStyle[col], ""));
					}
					if (rowspan[row][col] > 1) {
						html.append(" rowspan=\"");
						html.append(rowspan[row][col]);
						html.append("\" ");
					}
					html.append(">");
					html.append(rows[col]);
					html.append("</td>");
				}
			}
			html.append("</tr>");
			row++;
		}
		return html.toString();
	}

	/**
	 * 输入按钮名称，根据名称长短，返回按钮名称和样式(value,class,onmouseover,onmouseout)
	 * @author dyh 2009-10-24
	 * @param buttonName
	 * @return
	 */
	public static String getButtonClass(String buttonName) {
		buttonName = buttonName.replace("&nbsp;", " ").trim();
		int len = getStringLength(buttonName);
		String buttonClass = "button";
		return " style=\"width:" + (len * 7 + 13) + "px\" " + " value=\"" + buttonName + "\" class=\"" + buttonClass
				+ "\" onmouseover=\"this.className='" + buttonClass + "_over'\" onmouseout=\"this.className='" + buttonClass + "'\" ";
	}

	/**
	 * 返回按钮样式(含disable样式)
	 * @author dyh 2009-10-24
	 * @author dyh 2009-09-29
	 * @param disable
	 * @param buttonName
	 * @return
	 */
	public static String getButtonClass(boolean disable, String buttonName) {
		if (disable) {
			buttonName = buttonName.replace("&nbsp;", " ").trim();
			int len = getStringLength(buttonName);
			String buttonClass = "button_disable";
			return " style=\"width:" + (len * 7 + 13) + "px\" " + " value=\"" + buttonName + "\" class=\"" + buttonClass + "\" disabled=\"true\" ";
		} else
			return MyFormat.getButtonClass(buttonName);
	}

	/**
	 * 规格化文件大小：输入字节数，获取b,K或M字节
	 * @author dyh 2010-07-16
	 * @param filelen 字节数
	 * @return b,K或M
	 */
	public static String formatFileLength(long filelen) {
		String strLen = "";
		if (filelen < 1024)
			strLen = String.valueOf(filelen) + " ";
		else if (filelen < 1024 * 1024) {
			strLen = new DecimalFormat("0.#").format(filelen / 1024.0) + " K";
		} else {
			strLen = new DecimalFormat("0.#").format(filelen / (1024.0 * 1024)) + " M";
		}
		return strLen + "bytes";
	}

	/**
	 * 除法
	 * @author YOUCL 2011-1-2
	 * @param divider 除数
	 * @param total 被除数
	 * @return
	 */
	public static String divide(int total, int divider) {
		if (divider <= 0)
			return "0";
		return new DecimalFormat("0.#").format(total * 1.0 / divider);
	}

	/**
	 * 去除所有含<>的代码
	 * @author dyh 2009-11-15
	 * @param content 要格式化的内容
	 * @return
	 */
	public static String removeAllHTML(String content) {
		if (content != null && content.length() > 0) {
			content = content.trim();
			if (content.length() > 0) {
				if (content.indexOf("<") > -1)
					content = content.replaceAll("<([^<>]*)>", "").trim();
			}
		}
		return content;
	}

	/**
	 * 报表行列数据转换(以全省销售报表为例，表头为21个地市，表第一列为品牌，第二列为机型,则rows为机型的productid列表，cols为21个areaid)
	 * @author dyh 2009-10-27
	 * @param rows 行头编码列表(如：productid),最好经过排序
	 * @param cols 列头编码列表(如：areaid),最好经过排序
	 * @param data 从数据库取出的原始数据集,最好能按行编码和列编码进行排序，以便提高性能（如：含productid,areaid,quantity三个字段的集合，最好能按productid,areaid排序）
	 * @param hasRowTotal 是否需要合计一行中所有数量（如：某机型21个地市的总销量）
	 * @param hasColTotal 是否需要合计一列中所有数量（如：某地市所有机型的总销量）
	 * @return int[rows][cols]已经过行列转换整理的二维数组，用于显示到网页的表格中：
	 */
	public static double[][] data2Array(List<String> rows, List<String> cols, List<DataArray> data, boolean hasRowTotal, boolean hasColTotal) {

		// 行与列不允许为空
		if (cols == null || rows == null)
			return null;
		int colslen = cols.size();
		int rowslen = rows.size();

		int rowslenOK = rowslen + (hasColTotal ? 1 : 0);
		int colslenOK = colslen + (hasRowTotal ? 1 : 0);

		double[][] dataOK;
		if (colslen == 0 || rowslen == 0) {
			dataOK = new double[(rowslen == 0 ? 1 : rowslenOK)][(colslen == 0 ? 1 : colslenOK)];
			return dataOK;
		}

		String colcode = null;
		String rowcode = null;
		String colcodeold = null;
		String rowcodeold = null;
		double value = 0;

		dataOK = new double[rowslenOK][colslenOK];

		// 如果data为空，则返回一个0值的数组
		int datalen = data.size();
		if (data == null || datalen == 0) {
			return dataOK;
		}

		int rowIndex = -1;
		int colIndex = -1;
		// 遍历数据集
		for (int i = 0; i < datalen; i++) {
			if (data.get(i) == null)
				continue;
			rowcode = data.get(i).getRowcode();
			colcode = data.get(i).getColcode();
			value = data.get(i).getValue();
			if (i == 0) {
				rowcodeold = rowcode;
				colcodeold = colcode;
			}
			if (rowIndex == -1 || !rowcode.equals(rowcodeold)) {
				rowIndex = -1;// 未找到行
				for (int r = 0; r < rowslen; r++) {
					if (rowcode.equals(rows.get(r))) {
						rowIndex = r;
						break;
					}
				}
			}
			if (colIndex == -1 || !colcode.equals(colcodeold)) {
				colIndex = -1;// 未找到列
				for (int c = 0; c < colslen; c++) {
					if (colcode.equals(cols.get(c))) {
						colIndex = c;
						break;
					}
				}
			}
			if (rowIndex != -1 && colIndex != -1) {
				dataOK[rowIndex][colIndex] += value;
				if (hasRowTotal)
					dataOK[rowIndex][colslenOK - 1] += value;// 每行小计
				if (hasColTotal)
					dataOK[rowslenOK - 1][colIndex] += value;// 每列小计
				if (hasRowTotal && hasColTotal)
					dataOK[rowslenOK - 1][colslenOK - 1] += value;// 全表合计
			}
			rowcodeold = rowcode;
			colcodeold = colcode;
		}
		return dataOK;
	}

	/**
	 * 报表行列数据转换(以省连锁渠道销售明细报表为例，表头为两行：第一行为7家连锁企业，第二行为每家连锁下面的21个地市列表，相当于第二行长度至少为7*21；第一列为品牌，第二列为机型；则rows为机型的productid列表， cols1为7家连锁组织编码，cols2为21个areaid))
	 * @author dyh 2009-10-27
	 * @param rows 行编码列表(如：productid),最好经过排序
	 * @param cols1 列头1编码列表(如：7个连锁企业的编码),最好经过排序
	 * @param cols2 列头2编码列表(如：21个areaid),最好经过排序
	 * @param data 从数据库取出的原始数据集,最好能按行编码和列编码进行排序，以便提高性能（如：含productid,orgacode,areaid,quantity四个字段的集合，最好能按productid,orgacode ,areaid排序）
	 * @param hasRowTotal 是否需要合计一行中cols2所有数量（如：某机型每家连锁企业各地市总销量）
	 * @param hasRepeatCount 是否需要按cols1小计数量（如：某机某连锁21个地市的小计销量，7个连锁则有7个小计数量）
	 * @param hasColTotal 是否需要合计一列中所有数量（如：某连锁企业的某地市所有机型的总销量）
	 * @return int[rows][cols]已经过行列转换整理的二维数组，用于显示到网页的表格中：
	 */
	public static int[][] data2ArrayColRepeat(List<String> rows, List<String> cols1, List<String> cols2, List<DataArrayColRepeat> data,
			boolean hasRowTotal, boolean hasRepeatCount, boolean hasColTotal) {
		// 行与列不允许为空
		if (cols1 == null || cols2 == null || rows == null)
			return null;
		int cols1len = cols1.size();
		int cols2len = cols2.size();
		int rowslen = rows.size();
		int datalen = data.size();
		if (cols1len == 0 || cols2len == 0 || rowslen == 0)
			return null;

		String col1code = null;
		String col2code = null;
		String rowcode = null;
		String col1codeold = null;
		String col2codeold = null;
		String rowcodeold = null;
		int value = 0;

		int rowslenOK = rowslen + (hasColTotal ? 1 : 0);
		int colslenOK = cols1len * cols2len + (hasRepeatCount ? cols1len : 0) + (hasRowTotal ? cols2len + (hasRepeatCount ? 1 : 0) : 0);
		int[][] dataOK = new int[rowslenOK][colslenOK];

		// 如果data为空，则返回一个0值的数组
		if (data == null || datalen == 0) {
			return dataOK;
		}

		int rowIndex = -1;
		int colIndex = -1;
		int col1Index = -1;
		int col2Index = -1;
		// 遍历数据集
		for (int i = 0; i < datalen; i++) {
			if (data.get(i) == null)
				continue;
			rowcode = data.get(i).getRowcode();
			col1code = data.get(i).getCol1code();
			col2code = data.get(i).getCol2code();
			value = data.get(i).getValue();
			if (i == 0) {
				rowcodeold = rowcode;
				col1codeold = col1code;
				col2codeold = col2code;
			}
			if (rowIndex == -1 || !rowcode.equals(rowcodeold)) {
				rowIndex = -1;// 未找到行
				for (int r = 0; r < rowslen; r++) {
					if (rowcode.equals(rows.get(r))) {
						rowIndex = r;
						break;
					}
				}
			}
			if (col1Index == -1 || !col1code.equals(col1codeold)) {
				col1Index = -1;// 未找到列头1
				for (int c = 0; c < cols1len; c++) {
					if (col1code.equals(cols1.get(c))) {
						col1Index = c;
						break;
					}
				}
			}
			if (col1Index != -1) {
				if (col2Index == -1 || !col2code.equals(col2codeold)) {
					col2Index = -1;// 未找到列头2
					for (int c = 0; c < cols2len; c++) {
						if (col2code.equals(cols2.get(c))) {
							col2Index = c;
							break;
						}
					}
				}
			}
			if (rowIndex != -1 && col1Index != -1 && col2Index != -1) {
				colIndex = col1Index * cols2len + col2Index + (hasRepeatCount ? col1Index : 0);
				dataOK[rowIndex][colIndex] += value;
				if (hasRepeatCount)
					dataOK[rowIndex][(col1Index + 1) * cols2len + col1Index] += value;// 按cols1小计数量
				if (hasRowTotal) {// 每行小计
					dataOK[rowIndex][cols1len * cols2len + (hasRepeatCount ? cols1len : 0) + col2Index] += value;
					if (hasRepeatCount)
						dataOK[rowIndex][colslenOK - 1] += value;// 每行最后一列合计
				}
				if (hasColTotal) {
					dataOK[rowslenOK - 1][colIndex] += value;// 每列小计
					dataOK[rowslenOK - 1][(col1Index + 1) * cols2len + col1Index] += value;// 每列小计
					if (hasRowTotal) {// 每行小计
						dataOK[rowslenOK - 1][cols1len * cols2len + (hasRepeatCount ? cols1len : 0) + col2Index] += value;
					}
				}
				if (hasRowTotal && hasColTotal)
					dataOK[rowslenOK - 1][colslenOK - 1] += value;// 全表合计
			}
			rowcodeold = rowcode;
			col1codeold = col1code;
			col2codeold = col2code;
		}
		return dataOK;
	}

	/**
	 * 报表行列数据转换(举例：表最左侧有两列：第一列为地市，第二列为每个地市相同数量各种渠道类型,则rows1为地市,rows2为渠道类型)
	 * @author dyh 2011-01-20
	 * @param rows1 行1编码列表
	 * @param row2 行2编码列表
	 * @param cols 列头编码列表
	 * @param data 从数据库取出的原始数据集,最好能按行编码和列编码进行排序，以便提高性能（如：含productid,orgacode,areaid,quantity四个字段的集合，最好能按productid,orgacode ,areaid排序）
	 * @param hasRowTotal 是否需要合计一行中所有数量（如：某机型所有7家连锁企业的总销量）
	 * @param hasRepeatCount 是否需要按cols1小计数量（如：某机某连锁21个地市的小计销量，7个连锁则有7个小计数量）
	 * @param hasColTotal 是否需要合计一列中所有数量（如：某连锁企业的某地市所有机型的总销量）
	 * @return int[rows][cols]已经过行列转换整理的二维数组，用于显示到网页的表格中：
	 */
	public static double[][] data2ArrayRowRepeat(List<String> rows1, List<String> rows2, List<String> cols, List<DataArrayRowRepeat> data,
			boolean hasRowTotal, boolean hasRepeatCount, boolean hasColTotal) {
		// 行与列不允许为空
		if (rows1 == null || rows2 == null || cols == null)
			return null;
		int rows1len = rows1.size();
		int rows2len = rows2.size();
		int colslen = cols.size();
		int datalen = data.size();
		if (rows1len == 0 || rows2len == 0 || colslen == 0)
			return null;

		String row1code = null;
		String row2code = null;
		String colcode = null;
		String row1codeold = null;
		String row2codeold = null;
		String colcodeold = null;
		double value = 0;

		int colslenOK = colslen + (hasRowTotal ? 1 : 0);
	//	int rowslenOK = rows1len * rows2len + (hasRepeatCount ? rows1len : 0) + (hasColTotal ? 1 : 0);
		int rowslenOK=rows1len+(hasColTotal ? 1 : 0);
		double[][] dataOK = new double[rowslenOK][colslenOK];

		// 如果data为空，则返回一个0值的数组
		if (data == null || datalen == 0) {
			return dataOK;
		}

		int rowIndex = -1;
		int colIndex = -1;
		int row1Index = -1;
		int row2Index = -1;
		// 遍历数据集
		for (int i = 0; i < datalen; i++) {
			if (data.get(i) == null)
				continue;
			row1code = data.get(i).getRow1code();
			row2code = data.get(i).getRow2code();
			colcode = data.get(i).getColcode();
			value = data.get(i).getValue();
			if (i == 0) {
				row1codeold = row1code;
				row2codeold = row2code;
				colcodeold = colcode;
			}
			if (colIndex == -1 || !colcode.equals(colcodeold)) {
				colIndex = -1;// 未找到列
				for (int c = 0; c < colslen; c++) {
					if (colcode.equals(cols.get(c))) {
						colIndex = c;
						break;
					}
				}
			}
			if (row1Index == -1 || !row1code.equals(row1codeold)) {
				row1Index = -1;// 未找到行头1
				for (int r = 0; r < rows1len; r++) {
					if (row1code.equals(rows1.get(r)) && row2code.equals(rows2.get(r))) {
						row1Index = r;
						break;
					}
				}
			}
			if (row1Index != -1) {
				if (row2Index == -1 || !row2code.equals(row2codeold)) {
					row2Index = -1;// 未找到列头1
					for (int r = 0; r < rows2len; r++) {
						if (row2code.equals(rows2.get(r)) && row1code.equals(rows1.get(r))) {
							row2Index = r;
							break;
						}
					}
				}
			}
			if (colIndex != -1 && row1Index != -1 && row2Index != -1) {
		//		rowIndex = row1Index * rows2len + row2Index + (hasRepeatCount ? row1Index : 0);
				rowIndex=row1Index>row2Index?row1Index:row2Index;
				dataOK[rowIndex][colIndex] += value;
				if (hasRepeatCount)
					dataOK[(row1Index + 1) * rows2len + row1Index][colIndex] += value;// 按rows1小计数量
				if (hasColTotal)
					dataOK[rowIndex][colslenOK - 1] += value;// 每列小计
				if (hasRowTotal) {
					dataOK[rowslenOK - 1][colIndex] += value;// 每行小计
					// dataOK[(row1Index + 1) * rows2len + row1Index][colIndex] += value;// 每行小计
				}
				if (hasRowTotal && hasColTotal)
					dataOK[rowslenOK - 1][colslenOK - 1] += value;// 全表合计
			}
			colcodeold = colcode;
			row1codeold = row1code;
			row2codeold = row2code;
		}
		return dataOK;
	}
	/******************* 99. 控件、网页、IMEI、路径相关方法结束 ***************************/
}